home *** CD-ROM | disk | FTP | other *** search
/ Trading on the Edge / Trading On The Edge - CD-ROM Toolkit (Wayzata Technology)(2031)(1994).bin / pc / mac_file / vendor_d / neuralwa / nw2v50 / uctlio.c < prev    next >
Text File  |  1993-08-23  |  8KB  |  348 lines
  1. /* uctlio.c */
  2. /************************************************************************
  3.  * Copyright(C) 1987-1992 NeuralWare Inc                                *
  4.  * Penn Center West, IV-227, Pittsburgh, PA 15276                       *
  5.  * Telephone: (412) 787-8222    FAX: (412) 787-8220                     *
  6.  *                                                                      *
  7.  * All rights reserved.  No part of this program may be reproduced,     *
  8.  * stored in a retrieval system, or transmitted, in any form or by any  *
  9.  * means, electronic, mechanical, photocopying, recording or otherwise  *
  10.  * without the prior written permission of the copyright owner,         *
  11.  * NeuralWare, Inc.                                                     *
  12.  *                                                                      *
  13.  *                          PROPRIETARY NOTICE                          *
  14.  *                                                                      *
  15.  * This document is the property of NeuralWare, Inc. and contains       *
  16.  * trade-secrets and other proprietary information.  The information    *
  17.  * herein is reserved as proprietary to NeuralWare, and is not to be    *
  18.  * published, reproduced, copied, disclosed, used, or reverse           *
  19.  * engineered without the express written consent of a duly authorized  *
  20.  * representative of NeuralWare.                                        *
  21.  ************************************************************************
  22.  */
  23.  
  24. /*******************************************************************/
  25. /*                                                                 */
  26. /*    uctlio.c  - Sample User IO control program showing format of */
  27. /*                 all commands from NeuralWorks.                  */
  28. /*                                                                 */
  29. /*    Author: John C. Fairman           August 31, 1990            */
  30. /*    Copyright 1990 by NeuralWare Inc.                            */
  31. /*                                                                 */
  32. /*    $Author   :  $                                               */
  33. /*    $Date     :  $                                               */
  34. /*    $Source   :  $                                               */
  35. /*    $Revision :  $                                               */
  36. /*    $Log      :  $                                               */
  37. /*                                                                 */
  38. /*******************************************************************/
  39.  
  40. #define UIO_SERVER             1
  41. #define SERVER_EMULATOR_FILE   1
  42. #define SKIP_COMPAT_DATA       1
  43. #include "userutl.h"
  44. #include "uio_strc.h"
  45. #include "uio_tran.h"
  46. #include "uio_reqs.pro"
  47. #include "uio_cmds.pro"
  48.  
  49. #ifdef MAC
  50. #include "macuio.redef"
  51. #endif
  52.  
  53. /*******************************************************************/
  54. /*                                                                 */
  55. /* Functions necessary for handling the User I/O package itself.   */
  56. /*                                                                 */
  57. /*******************************************************************/
  58.  
  59. /* FUNCTION */
  60. NINT UIO_Init(file)
  61. TEXT *file;
  62. {
  63.   NINT ret_val = UIO_OK;
  64.  
  65.  
  66.   /* USER TO PLACE CODE HERE */
  67.  
  68.   return(ret_val);
  69. }
  70.  
  71.  
  72. /* */
  73. /* FUNCTION */
  74. NINT UIO_Term(process)
  75. NINT process;
  76. {
  77.   PutStr( "Control: bye bye\n" );
  78.  
  79.   return(UIO_OK);
  80. }
  81.  
  82.  
  83. /* FUNCTION */
  84. NINT UIO_Attention()
  85. {
  86.         int   wx;       /* work index */
  87.         char  buf[100];       /* work buffer */
  88.  
  89.   if ( (wx = ug_loadnet( "samplec" )) != 0 ) {
  90.       sprintf( buf, "could not load samplec, rc = %d", wx );
  91.       PutStr( buf );
  92.       GetStr();
  93.       return(UIO_OK);
  94.   }
  95.  
  96.   ug_learn( 100l );   /* learn a while */
  97.   ug_msgio( &buf[0], sizeof(buf), 0 );
  98.   PutStr( buf );      /* tell what User I/O did */
  99.   PutStr( "\n" );
  100.   ug_recall( 0l );    /* recall all */
  101.   ug_msgio( &buf[0], sizeof(buf), 0 );
  102.   PutStr( buf );      /* tell what User I/O did */
  103. #if 0
  104.   PutStr( "\n" );
  105. #endif
  106.   GetStr();
  107.  
  108.   return(UIO_OK);
  109. }
  110.  
  111. /******************************************************************/
  112. /*                                                                */
  113. /* In a User Control program only needs the following functions   */
  114. /* to avoid link errors. You do not need to provide code for any  */
  115. /* of them.                                                       */
  116. /*                                                                */
  117. /******************************************************************/
  118.  
  119. /*******************************************************************/
  120. /*                                                                 */
  121. /*  Functions necessary for handling a learning session.           */
  122. /*                                                                 */
  123. /*******************************************************************/
  124.  
  125. /* FUNCTION */
  126. NINT UIO_Learn_Start()
  127. {
  128.   NINT ret_val = UIO_OK;
  129.  
  130.  
  131.   /* USER TO PLACE CODE HERE */
  132.  
  133.   return(ret_val);
  134. }
  135.  
  136.  
  137. /* */
  138. /* FUNCTION */
  139. NINT UIO_Learn_Input(LayN, nPEs, Datap)
  140. NINT  LayN;
  141. NINT  nPEs;
  142. SREAL *Datap;
  143. {
  144.   NINT ret_val = UIO_OK;
  145.  
  146.  
  147.   /* USER TO PLACE CODE HERE */
  148.  
  149.   return(ret_val);
  150. }
  151.  
  152.  
  153. /* FUNCTION */
  154. NINT UIO_Learn_Output(LayN, nPEs, Datap)
  155. NINT  LayN;
  156. NINT  nPEs;
  157. SREAL *Datap;
  158. {
  159.   NINT ret_val = UIO_OK;
  160.  
  161.  
  162.   /* USER TO PLACE CODE HERE */
  163.  
  164.   return(ret_val);
  165. }
  166.  
  167.  
  168. /* */
  169. /* FUNCTION */
  170. NINT UIO_Learn_Result(LayN, nPEs, Datap)
  171. NINT  LayN;
  172. NINT  nPEs;
  173. SREAL *Datap;
  174. {
  175.   NINT ret_val = UIO_OK;
  176.  
  177.  
  178.   /* USER TO PLACE CODE HERE */
  179.  
  180.   return(ret_val);
  181. }
  182.  
  183.  
  184. /* FUNCTION */
  185. NINT UIO_Learn_End()
  186. {
  187.   NINT ret_val = UIO_OK;
  188.  
  189.  
  190.   /* USER TO PLACE CODE HERE */
  191.  
  192.   return(ret_val);
  193. }
  194.  
  195.  
  196. /* */
  197. /*******************************************************************/
  198. /*                                                                 */
  199. /*  Functions necessary for handling a recall or testing session.  */
  200. /*                                                                 */
  201. /*******************************************************************/
  202.  
  203. /* FUNCTION */
  204. NINT UIO_Recall_Start()
  205. {
  206.   NINT ret_val = UIO_OK;
  207.  
  208.  
  209.   /* USER TO PLACE CODE HERE */
  210.  
  211.   return(ret_val);
  212. }
  213.  
  214.  
  215. /* FUNCTION */
  216. NINT UIO_Read(LayN, nPEs, Datap)
  217. NINT  LayN;
  218. NINT  nPEs;
  219. SREAL *Datap;
  220. {
  221.   NINT ret_val = UIO_OK;
  222.  
  223.  
  224.   /* USER TO PLACE CODE HERE */
  225.  
  226.   return(ret_val);
  227. }
  228.  
  229.  
  230. /* */
  231. /* FUNCTION */
  232. NINT UIO_Write(LayN, nPEs, Datap)
  233. NINT  LayN;
  234. NINT  nPEs;
  235. SREAL *Datap;
  236. {
  237.   NINT ret_val = UIO_OK;
  238.  
  239.  
  240.   /* USER TO PLACE CODE HERE */
  241.  
  242.   return(ret_val);
  243. }
  244.  
  245.  
  246. /* FUNCTION */
  247. NINT UIO_Write_Step(LayN, nPEs, Datap)
  248. NINT  LayN;
  249. NINT  nPEs;
  250. SREAL *Datap;
  251. {
  252.   NINT ret_val = UIO_OK;
  253.  
  254.  
  255.   /* USER TO PLACE CODE HERE */
  256.  
  257.   return(ret_val);
  258. }
  259.  
  260.  
  261. /* */
  262. /* FUNCTION */
  263. NINT UIO_Recall_Test(LayN, nPEs, Datap)
  264. NINT  LayN;
  265. NINT  nPEs;
  266. SREAL *Datap;
  267. {
  268.   NINT ret_val = UIO_OK;
  269.  
  270.  
  271.   /* USER TO PLACE CODE HERE */
  272.  
  273.   return(ret_val);
  274. }
  275.  
  276. /* FUNCTION */
  277. NINT UIO_Recall_End()
  278. {
  279.   NINT ret_val = UIO_OK;
  280.  
  281.  
  282.   /* USER TO PLACE CODE HERE */
  283.  
  284.   return(ret_val);
  285. }
  286.  
  287.  
  288. /* */
  289. /*******************************************************************/
  290. /*                                                                 */
  291. /*  Other miscelaneous functions.                                  */
  292. /*                                                                 */
  293. /*******************************************************************/
  294.  
  295. /* FUNCTION */
  296. NINT UIO_Instrument(Instrument_id, nDataElems, DataElemp)
  297. NINT  Instrument_id;
  298. NINT  nDataElems;
  299. SREAL *DataElemp;
  300. {
  301.   NINT ret_val = UIO_OK;
  302.  
  303.  
  304.   /* USER TO PLACE CODE HERE */
  305.  
  306.   return(ret_val);
  307. }
  308.  
  309.  
  310. /* FUNCTION */
  311. NINT UIO_ObjFunc(eoeflag, DataElemp)
  312. NINT  eoeflag;
  313. SREAL *DataElemp;
  314. {
  315.   NINT ret_val = UIO_OK;
  316.  
  317.   /* USER TO PLACE CODE HERE */
  318.  
  319.   return(ret_val);
  320. }
  321.  
  322. /* FUNCTION */
  323. NINT UIO_Rewind()
  324. {
  325.   NINT ret_val = UIO_OK;
  326.  
  327.  
  328.   /* USER TO PLACE CODE HERE */
  329.  
  330.   return(ret_val);
  331. }
  332.  
  333.  
  334. /* */
  335. /* FUNCTION */
  336. NINT UIO_Explain(LayN, nPEs, Datap)
  337. NINT  LayN;
  338. NINT  nPEs;
  339. SREAL *Datap;
  340. {
  341.   NINT ret_val = UIO_OK;
  342.  
  343.  
  344.   /* USER TO PLACE CODE HERE */
  345.  
  346.   return(ret_val);
  347. }
  348.